// API基础URL配置 - 根据环境动态设置
const getApiBaseUrl = () => {
  // 手动切换开关 - 修改这里来切换环境
  const USE_LOCAL_SERVER = false; // 改为 true 使用本地服务器，false 使用远程服务器
  
  // 检查是否在微信小程序环境
  if (typeof wx !== 'undefined' && wx.getSystemInfoSync) {
    // 微信小程序环境，使用完整域名
    return USE_LOCAL_SERVER ? 'http://localhost:8080' : 'https://tongxiaojun.club';
  }
  
  // 在H5开发环境中，使用相对路径通过vite代理
  if (typeof window !== 'undefined' && window.location) {
    const hostname = window.location.hostname;
    if (hostname === 'localhost' || hostname === '127.0.0.1') {
      // H5开发环境使用相对路径，通过vite代理转发到后端
      return '';
    }
  }
  
  // 如果手动指定使用本地服务器（其他环境）
  if (USE_LOCAL_SERVER) {
    return 'http://localhost:8080';
  }
  
  // H5生产环境使用相对路径，利用nginx代理
  return '';
};

const API_BASE_URL = getApiBaseUrl();
const API_VERSION = 'v1';
const API_PREFIX = 'api';

// 简单的内存缓存
const cache = new Map();
const CACHE_DURATION = 5 * 60 * 1000; // 5分钟缓存

/**
 * 生成缓存键
 * @param {string} url - 请求URL
 * @param {object} options - 请求选项
 * @returns {string} 缓存键
 */
const getCacheKey = (url, options = {}) => {
  return `${options.method || 'GET'}_${url}_${JSON.stringify(options.body || {})}`;
};

/**
 * 检查缓存是否有效
 * @param {object} cacheItem - 缓存项
 * @returns {boolean} 是否有效
 */
const isCacheValid = (cacheItem) => {
  return cacheItem && (Date.now() - cacheItem.timestamp) < CACHE_DURATION;
};

/**
 * 带重试机制的请求方法
 * @param {string} url - 请求URL
 * @param {object} options - 请求选项
 * @param {number} retryCount - 重试次数
 * @returns {Promise} 请求结果
 */
const requestWithRetry = async (url, options = {}, retryCount = 0) => {
  const maxRetries = 3;
  const retryDelay = Math.pow(2, retryCount) * 1000; // 指数退避
  
  console.log('🌐 发送uni.request:', {
    url,
    method: options.method || 'GET',
    retryCount: retryCount + 1,
    maxRetries: maxRetries + 1
  });
  
  return new Promise((resolve, reject) => {
    uni.request({
      url,
      method: options.method || 'GET',
      data: options.body,
      timeout: 10000, // 10秒超时
      header: {
        'Content-Type': 'application/json',
        ...options.headers
      },
      success: (res) => {
        console.log('✅ uni.request成功响应:', {
          statusCode: res.statusCode,
          dataCode: res.data?.code,
          hasData: !!res.data,
          url: url
        });
        
        const data = res.data;
        
        // 检查HTTP状态码
        if (res.statusCode >= 200 && res.statusCode < 300) {
          // 检查业务状态码
          if (data.code !== 200) {
            console.error('❌ 业务状态码错误:', data.code, data.message);
            reject(new Error(data.message || '请求失败'));
          } else {
            console.log('🎉 请求完全成功');
            resolve(data);
          }
        } else {
          console.error('❌ HTTP状态码错误:', res.statusCode);
          reject(new Error(`HTTP ${res.statusCode}: ${data.message || '请求失败'}`));
        }
      },
      fail: (error) => {
        console.error(`❌ uni.request请求失败 (尝试 ${retryCount + 1}/${maxRetries + 1}):`, {
          url: url,
          error: error,
          errMsg: error.errMsg,
          message: error.message
        });
        
        // 如果还有重试次数，则重试
        if (retryCount < maxRetries) {
          setTimeout(() => {
            requestWithRetry(url, options, retryCount + 1)
              .then(resolve)
              .catch(reject);
          }, retryDelay);
        } else {
          reject(new Error(`请求失败，已重试${maxRetries}次: ${error.errMsg || error.message || '网络错误'}`));
        }
      }
    });
  });
};

/**
 * 通用请求方法（带缓存和重试）
 * @param {string} url - 请求URL
 * @param {object} options - 请求选项
 * @returns {Promise} 请求结果
 */
const request = async (url, options = {}) => {
  // 根据环境构建完整URL
  const fullUrl = API_BASE_URL ? `${API_BASE_URL}/${API_PREFIX}/${API_VERSION}${url}` : `/${API_PREFIX}/${API_VERSION}${url}`;
  
  console.log('🔧 API请求构建:', {
    originalUrl: url,
    baseUrl: API_BASE_URL,
    fullUrl: fullUrl,
    method: options.method || 'GET'
  });
  
  // 只对GET请求使用缓存
  if (!options.method || options.method === 'GET') {
    const cacheKey = getCacheKey(url, options);
    const cachedItem = cache.get(cacheKey);
    
    if (isCacheValid(cachedItem)) {
      console.log('使用缓存数据:', url);
      return Promise.resolve(cachedItem.data);
    }
    
    try {
      const result = await requestWithRetry(fullUrl, options);
      // 缓存成功的GET请求结果
      cache.set(cacheKey, {
        data: result,
        timestamp: Date.now()
      });
      return result;
    } catch (error) {
      throw error;
    }
  } else {
    // 非GET请求不使用缓存
    return requestWithRetry(fullUrl, options);
  }
};

// 页面相关API
const page = {
  // 获取页面数据 (兼容旧版本，不需要认证)
  getPageData: (pageType) => {
    return request(`/page/${pageType}`);
  },
  
  // 获取页面内容
  getPageContent: (pageId) => {
    return request(`/pages/content/${pageId}`);
  }
};

// 内容相关API
const content = {
  // 获取内容详情
  getDetail: (contentPath) => {
    return request(`/content/${contentPath}`);
  },
  
  // 获取markdown内容
  getMarkdown: (endpoint) => {
    return request(endpoint);
  }
};

// 分类相关API
const category = {
  // 获取分类列表
  getList: () => {
    return request('/categories');
  },
  
  // 获取分类详情
  getDetail: (id) => {
    return request(`/categories/${id}`);
  }
};

// 项目相关API
const item = {
  // 获取项目列表
  getList: (params = {}) => {
    const queryString = new URLSearchParams(params).toString();
    return request(`/items?${queryString}`);
  },
  
  // 获取项目列表（别名方法，兼容性）
  getItems: (params = {}) => {
    const queryString = new URLSearchParams(params).toString();
    return request(`/items?${queryString}`);
  },
  
  // 获取项目详情
  getDetail: (id) => {
    return request(`/items/${id}`);
  },
  
  // 获取项目详情（别名方法，兼容性）
  getItem: (id) => {
    return request(`/items/${id}`);
  },
  
  // 获取页面项目及其关联的项目
  getItemWithRelatedItems: (id) => {
    return request(`/items/${id}/relations`);
  },
  
  // 获取页面项目的关联关系
  getPageItemRelations: (pageItemId) => {
    return request(`/items/${pageItemId}/relations`);
  },
  
  // 获取项目的相关数据 (用于content_type为page的item)
  getRelatedItems: (id) => {
    return request(`/items/${id}/related`);
  }
};

// 用户相关API
const user = {
  // 用户登录
  login: (credentials) => {
    return request('/auth/login', {
      method: 'POST',
      body: credentials
    });
  },
  
  // 获取用户信息
  getProfile: () => {
    return request('/user/profile');
  }
};

export default {
  page,
  content,
  category,
  item,
  user
};